home *** CD-ROM | disk | FTP | other *** search
/ FM Towns: Free Software Collection 6 / FM Towns Free Software Collection 6.iso / t_os / igo / src / kifuctrl.c < prev    next >
C/C++ Source or Header  |  1993-07-08  |  12KB  |  657 lines
  1. #define DEBUG 0
  2. /* 
  3.     TOWNS囲碁棋譜記録プログラム
  4.                                           1992/02/25  久保田俊也
  5.  
  6.     91/02/25  kifuctrl モジュールを本体より分離 
  7.                 kifuデ－タを操作する関数の集まり 
  8.  
  9. */
  10. #include <stdio.h>
  11. #include "igo.h"
  12. #include "ban19.h"
  13. #include "kiffile.h"
  14. #define HEAD -1 /* ichiが-1の場合HEADとする */
  15. #define SPACE20 "                    "
  16.  
  17. char *comment_read(int comment_no);
  18.  
  19. TE *cell_get();
  20. TE_ARG cell_read();
  21.  
  22. static KIF_TITLE kif_title;
  23. static TE *current_te;
  24. static char ban[BANSIZE2];
  25. static int  numberdisp_flg = 1;    /* 手順表示する 0以外 しない 0 */
  26. static int  repeat_flg = 0;        /* リピ－トする 0以外 しない 0 */
  27. static int  change_flg = 0;     /* 変化再生する 0以外 しない 0 */
  28. static int  comment_flg = 1;    /* コメント表示する 0以外 しない 0 */
  29.  
  30. static TE *head;
  31.  
  32. int kifu_init()
  33. {
  34. int i;
  35.  
  36.     cell_init();
  37.     head = cell_get();
  38.     
  39.     comment_init();
  40.  
  41.     kif_title.ver = 2;    /* 93/3/1 変更 */
  42.     kif_title.handy = 0;
  43.     strcpy( kif_title.player_black , SPACE20);
  44.     strcpy( kif_title.player_white , SPACE20);
  45.     strcpy( kif_title.play_space , SPACE20);
  46.     kif_title.komi_id = -1;
  47.     kif_title.komi_number = -1;
  48.     kif_title.hanmoku_id = -1;
  49.     kif_title.vicdef_id = -1;
  50.     kif_title.vicdef_number = 0;
  51.     
  52.  
  53.     ban_init(19,ban);
  54.  
  55.     head->iro = WHITE;
  56.     for(i=0;i<BANSIZE2;i++){
  57.         head->ban[i] = ban[i];
  58.     }
  59.     head->brother = head;
  60.     head->prev    = head;
  61.     head->next    = head;
  62.     head->ichi    = HEAD;     /* たぶん使わないだろうけど問題か headの判定使用*/
  63.  
  64.     current_te   = head;
  65.     return 0;
  66. }
  67.  
  68. kifu_put(int ichi)
  69. {
  70. int i;
  71. TE *add_te;
  72. TE *temp;
  73.  
  74. #if DEBUG
  75.     printf("kifuctrl kifu_put!\n");
  76.     printf("ban[ichi] = %d ichi = %d\n", ban[ichi], ichi);
  77.     printf("current_te->iro = %d\n", current_te->iro);
  78. #endif
  79.  
  80.     if(ban[ichi]==BLACK || ban[ichi]==WHITE){
  81.         return 0;
  82.     }
  83.  
  84.     if(current_te->next->iro == DELETE){
  85.         add_te = current_te->next;
  86.     }else{
  87.         add_te = cell_get();
  88.         if(add_te == NULL){
  89.             printf("return of cell_get() = null!\n");
  90.             return 1;
  91.         }
  92.         add_te->comment = 0;
  93.         /*  次の手に兄弟がない */
  94.         if(current_te->next == current_te->next->brother){
  95.             add_te->brother = add_te;
  96.         /*  次の手が枝の頭ではない */
  97.         }else if(current_te->next->ichi != HEAD){
  98.             add_te->brother = current_te->next->brother;
  99.             for(temp=current_te->next;
  100.                 temp->brother != current_te->next;
  101.                 temp=temp->brother){
  102.                 ;
  103.             }
  104.             current_te->next->brother = temp->brother;
  105.             temp->brother = add_te;
  106.         /*  次の手が枝の頭で かつ 一番下の弟である */
  107.         }else if(current_te->next->brother->ichi != HEAD ||
  108.                  current_te->next->brother == head){
  109.             add_te->brother = add_te;
  110.         /*  次の手が枝の頭で かつ 下に弟がいる */
  111.         }else{
  112.             add_te->brother = current_te->next->brother;
  113.             for(temp=current_te->next;
  114.                 temp->brother->ichi == HEAD && temp->brother != head;
  115.                 temp=temp->brother){
  116.                 ;
  117.             }
  118.             current_te->next->brother = temp->brother;
  119.             temp->brother = add_te;
  120.         }
  121.         
  122.         add_te->prev = current_te;
  123.         add_te->next = current_te->next;
  124.         current_te->next->prev = add_te;
  125.         current_te->next       = add_te;
  126.     }
  127.  
  128.     ban[ichi] = 1 - current_te->iro;
  129.     uchiage(ichi, ban);
  130.     
  131.     add_te->ichi = ichi;
  132.     add_te->iro  = 1 - current_te->iro;
  133.     for(i=0;i<BANSIZE2;i++){
  134.         add_te->ban[i] = ban[i];
  135.     }
  136.  
  137.     
  138.     current_te = add_te;
  139.     return 0;
  140.  
  141. }
  142.  
  143. kifu_cancel()
  144. {
  145. int i;
  146. TE *save_te;
  147.  
  148.     if(current_te->ichi == HEAD || current_te->iro == DELETE){
  149.         return -1;
  150.     }
  151.  
  152.     if(current_te->brother != current_te || current_te->comment != 0){
  153.         current_te->iro = DELETE;
  154.         current_te = current_te->prev;
  155.     }else{
  156.         current_te->prev->next = current_te->next;
  157.         current_te->next->prev = current_te->prev;
  158.         save_te = current_te->prev;
  159.         cell_free(current_te);
  160.         current_te = save_te;
  161.     }
  162.     
  163.     for(i=0;i<BANSIZE2;i++){
  164.         ban[i] = current_te->ban[i];
  165.     }
  166.     return 0;
  167. }
  168.  
  169. int kifu_forward()
  170. {
  171. int i;
  172. TE *wk_te;
  173. TE *save_te;
  174.  
  175.     save_te = current_te;
  176.     do{
  177.         current_te = current_te->next;
  178.         if( change_flg != 0){
  179.             if(current_te != current_te->brother){
  180.                 current_te = current_te->brother;
  181.             }
  182.         }
  183.     }while(current_te->iro==DELETE);
  184.     
  185.     if(current_te->ichi==HEAD){
  186.         if(repeat_flg == 0 && change_flg == 0){
  187.             current_te = save_te;
  188.             return REPEAT_CANNOT_BOTTOM_CELL;
  189.         }
  190.         
  191.         if(current_te==head){
  192.             if(repeat_flg == 0){
  193.                 current_te = save_te;
  194.                 return REPEAT_CANNOT_BOTTOM_CELL;
  195.             }
  196.         
  197.             for(i=0;i<BANSIZE2;i++){
  198.                 ban[i] = current_te->ban[i];
  199.             }
  200.             return HEAD_CELL;
  201.         }else{
  202.             for(i=0;i<BANSIZE2;i++){
  203.                 if(change_flg == 0){
  204.                     ban[i] = current_te->ban[i];
  205.                 }else{
  206.                     current_te->ban[i] = ban[i];
  207.                 }
  208.             }
  209.             return BOTTOM_CELL;
  210.         }
  211.     }else{
  212.         /* 打ち上げ処理を行うために前の画面に戻る */
  213.         for(wk_te=current_te->prev;wk_te->iro==DELETE;wk_te=wk_te->prev){
  214.             ;
  215.         }
  216.         for(i=0;i<BANSIZE2;i++){
  217.             ban[i] = wk_te->ban[i];
  218.         }
  219.         
  220.         ban[current_te->ichi] = current_te->iro;
  221.         uchiage(current_te->ichi, ban);
  222.         for(i=0;i<BANSIZE2;i++){
  223.             current_te->ban[i] = ban[i];
  224.         }
  225.         return NORMAL_CELL;
  226.     }
  227.  
  228. }
  229.  
  230. int kifu_back()
  231. {
  232. int i;
  233. TE *wk_te;
  234.  
  235.     if(repeat_flg == 0 && change_flg == 0){
  236.         if(current_te->ichi == HEAD){
  237.             for(i=0;i<BANSIZE2;i++){
  238.                 ban[i] = current_te->ban[i] ;
  239.             }
  240.             return 0;
  241.         }
  242.     
  243.     }else if(repeat_flg == 0 && change_flg != 0){
  244.         if(current_te == head){
  245.             for(i=0;i<BANSIZE2;i++){
  246.                 ban[i] = current_te->ban[i] ;
  247.             }
  248.             return 0;
  249.         }
  250.     }
  251.     
  252.     do{
  253.         if(change_flg != 0){
  254.             if(current_te->brother!=current_te){
  255.                 for(wk_te=current_te;wk_te->brother!=current_te;wk_te=wk_te->brother){
  256.                     ;
  257.                 }
  258.                 current_te = wk_te;
  259.             }
  260.         }
  261.         current_te = current_te->prev;
  262.     }while(current_te->iro==DELETE);
  263.     
  264.     
  265.     for(i=0;i<BANSIZE2;i++){
  266.         ban[i] = current_te->ban[i] ;
  267.     }
  268.  
  269.     return 0;
  270. }
  271.  
  272. int kifu_first()
  273. {
  274. int i;
  275.     
  276.     if(change_flg != 0){
  277.         current_te = head;
  278.         for(i=0;i<BANSIZE2;i++){
  279.             ban[i] = head->ban[i] ;
  280.         }
  281.     }else{
  282.         for(current_te=current_te->next;current_te->ichi!=HEAD;current_te=current_te->next){
  283.             ;
  284.         }
  285.  
  286.         for(i=0;i<BANSIZE2;i++){
  287.             ban[i] = current_te->ban[i];
  288.         }
  289.     }
  290.     return 0;
  291. }
  292.  
  293. /* kifu_tmp_first()
  294. {
  295. int i;
  296.     
  297.     current_te = tmp_head;
  298.     for(i=0;i<BANSIZE2;i++){
  299.         ban[i] = tmp_head->ban[i] ;
  300.     }
  301. }*/
  302.  
  303. int kifu_read(char fname[])
  304. {
  305. int i;
  306.  
  307. KIF_TE        kiffile_te;
  308. TE_ARG        kiffile_te2;
  309.  
  310.     if(kiffile_read(fname) == -1){
  311.         return -1;
  312.     }
  313.     kiftitle_read(&kif_title);
  314.     
  315.     current_te = head;
  316.     ban_init(19,ban);
  317.  
  318.     if(kif_title.handy != 0){
  319.         handy_dispset(kif_title.handy, ban);
  320.         head->iro = BLACK;
  321.     }else{
  322.         head->iro = WHITE;
  323.     }
  324.     for(i=0;i<BANSIZE2;i++){
  325.         head->ban[i] = ban[i];
  326.     }
  327.     
  328.     for(i=1;i <= kif_title.te_number;i++){
  329.         kifte_read2(&kiffile_te2);
  330.         if(cell_write(kiffile_te2)== -1){
  331.             printf("cell_write error = %d!\n", kif_title.te_number);
  332.             return -1;
  333.         }
  334.     }
  335.         
  336.     if(cell_write_finish()== -1){
  337.         printf("cell_write error = %d!\n", kif_title.te_number);
  338.         return -1;
  339.     }
  340.         
  341.  
  342.     return 0;
  343. }
  344.  
  345. kifu_write(char fname[])
  346. {
  347. TE_ARG      kiffile_te;
  348.  
  349.     kiftitle_write(kif_title);
  350.     
  351.     kiffile_te = cell_read();
  352.     while(kiffile_te.no != -1){
  353.         kifte_write(kiffile_te);
  354.         kiffile_te = cell_read();
  355.     }
  356.     if(kiffile_write(fname) != 0){
  357.         return -1;
  358.     }
  359.     
  360.     return 0;
  361. }
  362.  
  363. kifu_handy(int handy)
  364. {
  365. int i;
  366.  
  367.     if(handy_dispset(handy, ban) == 0){
  368.         for(i=0;i<BANSIZE2;i++){
  369.             head->ban[i] = ban[i];
  370.         }
  371.         kif_title.handy = handy;
  372.         head->iro = BLACK;
  373.         current_te = head;
  374.         
  375.     }else{
  376.         return -1;
  377.     }
  378. }
  379.  
  380. kifu_disp()
  381. {
  382. int i;
  383. TE *wk_te;
  384. static int ex_ban[BANSIZE2];
  385.  
  386.     for(i=0;i<BANSIZE2;i++){
  387.         ex_ban[i] = 0;
  388.     }
  389.     
  390.     if(numberdisp_flg != 0){
  391.         for(wk_te=current_te;wk_te->prev->ichi!=HEAD;wk_te=wk_te->prev){
  392.             ;
  393.         }
  394.         
  395.         i=1;
  396.         for(;wk_te!=current_te->next;wk_te=wk_te->next){
  397.             if(wk_te->iro != DELETE){
  398.                 ex_ban[wk_te->ichi] = i;
  399.                 i++;
  400.             }
  401.         }
  402.     }
  403.     disp_te(ban,ex_ban);
  404. }
  405.  
  406. kifu_numberdisp()
  407. {
  408.     numberdisp_flg = 1-numberdisp_flg;
  409. }
  410.  
  411. kifu_print()
  412. {
  413. int i;
  414. int handy;
  415. int print_ban[BANSIZE2];
  416. TE *wk_te;
  417. struct {
  418.     int no;
  419.     int ichi;
  420.     int begin_no;
  421. }print_bangai[BANSIZE2];    /*  配列の大きさはいい加減もっと大きくとるべきだろうがいい加減にきめてある */
  422.  
  423.     for(i=0;i<BANSIZE2;i++){
  424.         print_ban[i] = 0;
  425.         print_bangai[i].no = 0;
  426.         print_bangai[i].ichi = 0;
  427.         print_bangai[i].begin_no = 0;
  428.     }
  429.     
  430.     handy = kif_title.handy;
  431.     handy_prinset(handy, print_ban);
  432.     
  433.     for(wk_te=head,i=0;wk_te->next!=head;wk_te=wk_te->next){
  434.         if(print_ban[wk_te->ichi]==0){
  435.             print_ban[wk_te->ichi] = i;
  436.         }else{
  437.             print_bangai[i].no = i;
  438.             print_bangai[i].ichi = wk_te->ichi;
  439.             print_bangai[i].begin_no = print_ban[wk_te->ichi];
  440.             i++;
  441.         }
  442.     }
  443. /*  現在サポ－トしていない */
  444. /*    print(print_ban, print_bangai); */
  445. }
  446.  
  447. kifu_chg_put()
  448. {
  449. int i;
  450. TE *wk_te;
  451. TE *tmp_head;
  452.  
  453.     tmp_head = cell_get();
  454.     if(tmp_head == NULL){
  455.         return 1;
  456.     }
  457.  
  458.     tmp_head->iro   = current_te->iro;
  459.     tmp_head->ichi  = HEAD;
  460.     for(i=0;i<BANSIZE2;i++){
  461.         tmp_head->ban[i] = ban[i];
  462.     }
  463.     for(wk_te = current_te->next;wk_te->brother !=wk_te;
  464.         wk_te = wk_te->brother->next){
  465.         ;
  466.     }
  467.     wk_te->brother    = tmp_head;
  468.     tmp_head->brother = wk_te;
  469.     tmp_head->prev    = tmp_head;
  470.     tmp_head->next    = tmp_head;
  471.     
  472.     current_te   = tmp_head;
  473.     
  474.     return 0;
  475. }
  476.  
  477. kifu_chg_cancel()
  478. {
  479. int i;
  480. TE *wk_te;
  481.  
  482.     if(current_te != current_te->next || current_te == head){
  483.         for(current_te=current_te->prev;current_te->ichi!=HEAD;current_te=current_te->prev){
  484.             ;
  485.         }
  486.  
  487.         do{
  488.             if(current_te->brother!=current_te){
  489.                 for(wk_te=current_te;wk_te->brother!=current_te;wk_te=wk_te->brother){
  490.                     ;
  491.                 }
  492.                 current_te = wk_te;
  493.             }
  494.             current_te = current_te->prev;
  495.         }while(current_te->iro==DELETE);
  496.     
  497.         for(i=0;i<BANSIZE2;i++){
  498.             ban[i] = current_te->ban[i];
  499.         }
  500.  
  501.         return 0;
  502.     }
  503.  
  504.     for(wk_te=current_te;wk_te->brother!=current_te;wk_te=wk_te->brother){
  505.         ;
  506.     }
  507.     wk_te->brother = current_te->brother;
  508.     cell_free(current_te);
  509.  
  510.     for(current_te=wk_te->prev;current_te->iro==DELETE;current_te=current_te->prev){
  511.         ;
  512.     }
  513.  
  514.     for(i=0;i<BANSIZE2;i++){
  515.         ban[i] = current_te->ban[i];
  516.     }
  517.  
  518.     return 0;
  519. }
  520.  
  521. int kifu_rebirth( int repeat_flag, int change_flag, int comment_flag )
  522. {
  523.  
  524.     repeat_flg = repeat_flag;
  525.     change_flg = change_flag;
  526.     comment_flg = comment_flag;
  527.     return 0;
  528. }
  529.  
  530. int kifu_blacknameset(char *blackname)
  531. {
  532.  
  533.     if(strlen(blackname) >= 21){
  534.         return -1;
  535.     }
  536.     strcpy( kif_title.player_black, blackname);
  537.     return 0;
  538. }
  539.  
  540. int kifu_blacknameread(char *blackname)
  541. {
  542.  
  543.     strcpy( blackname, kif_title.player_black);
  544.     return 0;
  545. }
  546.  
  547. int kifu_whitenameset(char *whitename)
  548. {
  549.  
  550.     if(strlen(whitename) >= 21){
  551.         return -1;
  552.     }
  553.     strcpy( kif_title.player_white, whitename);
  554.     return 0;
  555. }
  556.  
  557. int kifu_whitenameread(char *whitename)
  558. {
  559.  
  560.     strcpy( whitename, kif_title.player_white);
  561.     return 0;
  562. }
  563.  
  564. int kifu_playspaceset(char *play_space)
  565. {
  566.  
  567.     if(strlen(play_space) >= 21){
  568.         return -1;
  569.     }
  570.     strcpy( kif_title.play_space, play_space);
  571.     return 0;
  572. }
  573.  
  574. int kifu_playspaceread(char *play_space)
  575. {
  576.  
  577.     strcpy( play_space, kif_title.play_space);
  578.     return 0;
  579. }
  580.  
  581. int kifu_komiset(int komi_id, int komi_number, int hanmoku_id)
  582. {
  583.  
  584.     kif_title.komi_id = komi_id;
  585.     kif_title.komi_number = komi_number;
  586.     kif_title.hanmoku_id = hanmoku_id;
  587.     return 0;
  588. }
  589.  
  590. int kifu_komiread(int *komi_id, int *komi_number, int *hanmoku_id)
  591. {
  592.  
  593.     *komi_id = kif_title.komi_id;
  594.     *komi_number = kif_title.komi_number;
  595.     *hanmoku_id = kif_title.hanmoku_id;
  596.     return 0;
  597. }
  598.  
  599. int kifu_issueset(int vicdef_id, int vicdef_number)
  600. {
  601.  
  602.     kif_title.vicdef_id = vicdef_id;
  603.     kif_title.vicdef_number = vicdef_number;
  604.     return 0;
  605. }
  606.  
  607. int kifu_issueread(int *vicdef_id, int *vicdef_number)
  608. {
  609.  
  610.     *vicdef_id = kif_title.vicdef_id;
  611.     *vicdef_number = kif_title.vicdef_number;
  612.     return 0;
  613. }
  614.  
  615. int kifu_playstart_time_set(YMDHM play_start)
  616. {
  617.  
  618.     kif_title.play_start = play_start;
  619.     return 0;
  620. }
  621.  
  622. YMDHM *kifu_playstart_time_read()
  623. {
  624.     
  625.     return &(kif_title.play_start);
  626. }
  627.  
  628. int kifu_playend_time_set(YMDHM play_end)
  629. {
  630.  
  631.     kif_title.play_end = play_end;
  632.     return 0;
  633. }
  634.  
  635. YMDHM *kifu_playend_time_read()
  636. {
  637.     return &(kif_title.play_end);
  638.  
  639. }
  640.  
  641. int kifu_commentset(char *text)
  642. {
  643. int comment_no;
  644.  
  645.     comment_no = comment_set(text);
  646.     current_te->comment = (short int)comment_no;
  647.     return 0;
  648. }
  649.  
  650. char *kifu_commentread()
  651. {
  652.     
  653.     return comment_read((int)current_te->comment);
  654.  
  655. }
  656.  
  657.